import 'dart:math';

/// 医疗相关Mock API接口类
/// 提供用户认证、工作台、采购等功能的本地mock数据
class MedicalMockApis {
  static final Random _random = Random();

  // 模拟用户数据
  static final List<Map<String, dynamic>> _mockUsers = [
    {
      'id': '1001',
      'username': 'doctor01',
      'password': '123456',
      'phone': '13800138001',
      'name': '张医生',
      'avatar': 'https://picsum.photos/200/200?random=1',
      'department': '内科',
      'title': '主任医师',
      'hospital': '北京协和医院',
      'certification': '执业医师证：110101199001011234',
      'experience': '15年临床经验',
      'speciality': '心血管内科、高血压、冠心病',
    },
    {
      'id': '1002',
      'username': 'doctor02',
      'password': '123456',
      'phone': '13800138002',
      'name': '李医生',
      'avatar': 'https://picsum.photos/200/200?random=2',
      'department': '外科',
      'title': '副主任医师',
      'hospital': '上海华山医院',
      'certification': '执业医师证：310101198501011234',
      'experience': '12年临床经验',
      'speciality': '普外科、腹腔镜手术、胆囊疾病',
    },
  ];

  // 模拟患者数据
  static final List<Map<String, dynamic>> _mockPatients = [
    {
      'id': '2001',
      'name': '王小明',
      'age': 35,
      'gender': '男',
      'phone': '13900139001',
      'idCard': '110101198801011234',
      'address': '北京市朝阳区建国路88号',
      'medicalHistory': '高血压病史3年',
      'allergies': '青霉素过敏',
      'lastVisit': '2024-01-15',
      'status': '复诊',
    },
    {
      'id': '2002',
      'name': '李小红',
      'age': 28,
      'gender': '女',
      'phone': '13900139002',
      'idCard': '110101199601011234',
      'address': '北京市海淀区中关村大街123号',
      'medicalHistory': '无特殊病史',
      'allergies': '无',
      'lastVisit': '2024-01-16',
      'status': '初诊',
    },
    {
      'id': '2003',
      'name': '张大爷',
      'age': 68,
      'gender': '男',
      'phone': '13900139003',
      'idCard': '110101195601011234',
      'address': '北京市西城区西单大街456号',
      'medicalHistory': '糖尿病、高血压',
      'allergies': '磺胺类药物过敏',
      'lastVisit': '2024-01-14',
      'status': '复诊',
    },
  ];

  // 模拟处方数据
  static final List<Map<String, dynamic>> _mockPrescriptions = [
    {
      'id': 'P001',
      'patientId': '2001',
      'patientName': '王小明',
      'doctorName': '张医生',
      'date': '2024-01-15',
      'diagnosis': '高血压病',
      'medicines': [
        {
          'name': '硝苯地平缓释片',
          'specification': '30mg',
          'dosage': '每日1次，每次1片',
          'quantity': '30片',
          'price': 25.50,
        },
        {
          'name': '阿司匹林肠溶片',
          'specification': '100mg',
          'dosage': '每日1次，每次1片',
          'quantity': '30片',
          'price': 12.80,
        },
      ],
      'totalAmount': 38.30,
      'status': '已开具',
    },
    {
      'id': 'P002',
      'patientId': '2002',
      'patientName': '李小红',
      'doctorName': '张医生',
      'date': '2024-01-16',
      'diagnosis': '感冒',
      'medicines': [
        {
          'name': '感冒清热颗粒',
          'specification': '12g/袋',
          'dosage': '每日3次，每次1袋',
          'quantity': '9袋',
          'price': 18.60,
        },
      ],
      'totalAmount': 18.60,
      'status': '已开具',
    },
  ];

  // 模拟采购商品数据
  static final List<Map<String, dynamic>> _mockPurchaseItems = [
    {
      'id': 'I001',
      'name': '一次性医用口罩',
      'category': '防护用品',
      'brand': '3M',
      'specification': '50只/盒',
      'price': 45.00,
      'unit': '盒',
      'stock': 500,
      'supplierName': '北京医疗器械有限公司',
      'supplierPhone': '010-12345678',
      'imageUrl': 'https://picsum.photos/300/300?random=10',
      'description': '三层防护，过滤效率≥95%，符合医用标准',
      'certification': 'CE认证、FDA认证',
    },
    {
      'id': 'I002',
      'name': '医用酒精',
      'category': '消毒用品',
      'brand': '海氏海诺',
      'specification': '75%，500ml/瓶',
      'price': 12.50,
      'unit': '瓶',
      'stock': 200,
      'supplierName': '上海医药集团',
      'supplierPhone': '021-87654321',
      'imageUrl': 'https://picsum.photos/300/300?random=11',
      'description': '75%医用酒精，杀菌消毒，适用于皮肤和器械消毒',
      'certification': '药品生产许可证',
    },
    {
      'id': 'I003',
      'name': '一次性注射器',
      'category': '医疗器械',
      'brand': 'BD',
      'specification': '5ml，带针头',
      'price': 2.80,
      'unit': '支',
      'stock': 1000,
      'supplierName': '广州医疗设备公司',
      'supplierPhone': '020-11223344',
      'imageUrl': 'https://picsum.photos/300/300?random=12',
      'description': '一次性使用无菌注射器，安全便捷',
      'certification': '医疗器械注册证',
    },
    {
      'id': 'I004',
      'name': '血压计',
      'category': '检测设备',
      'brand': '欧姆龙',
      'specification': 'HEM-7136',
      'price': 298.00,
      'unit': '台',
      'stock': 50,
      'supplierName': '深圳医疗科技有限公司',
      'supplierPhone': '0755-99887766',
      'imageUrl': 'https://picsum.photos/300/300?random=13',
      'description': '全自动电子血压计，精准测量，操作简便',
      'certification': 'CFDA认证',
    },
  ];

  // 模拟采购订单数据
  static final List<Map<String, dynamic>> _mockPurchaseOrders = [
    {
      'id': 'O001',
      'orderNo': 'PO202401150001',
      'date': '2024-01-15',
      'status': 1, // 0:待确认 1:已确认 2:配送中 3:已完成 4:已取消
      'statusText': '已确认',
      'totalAmount': 1250.00,
      'items': [
        {
          'itemId': 'I001',
          'name': '一次性医用口罩',
          'quantity': 20,
          'price': 45.00,
          'subtotal': 900.00,
        },
        {
          'itemId': 'I002',
          'name': '医用酒精',
          'quantity': 28,
          'price': 12.50,
          'subtotal': 350.00,
        },
      ],
      'deliveryAddress': {
        'id': 'A001',
        'name': '张医生',
        'phone': '13800138001',
        'address': '北京市朝阳区建国路88号协和医院',
        'isDefault': true,
      },
    },
    {
      'id': 'O002',
      'orderNo': 'PO202401160001',
      'date': '2024-01-16',
      'status': 2,
      'statusText': '配送中',
      'totalAmount': 596.00,
      'items': [
        {
          'itemId': 'I003',
          'name': '一次性注射器',
          'quantity': 100,
          'price': 2.80,
          'subtotal': 280.00,
        },
        {
          'itemId': 'I004',
          'name': '血压计',
          'quantity': 1,
          'price': 298.00,
          'subtotal': 298.00,
        },
      ],
      'deliveryAddress': {
        'id': 'A001',
        'name': '张医生',
        'phone': '13800138001',
        'address': '北京市朝阳区建国路88号协和医院',
        'isDefault': true,
      },
    },
  ];

  // 模拟地址数据
  static final List<Map<String, dynamic>> _mockAddresses = [
    {
      'id': 'A001',
      'name': '张医生',
      'phone': '13800138001',
      'address': '北京市朝阳区建国路88号协和医院',
      'isDefault': true,
    },
    {
      'id': 'A002',
      'name': '张医生',
      'phone': '13800138001',
      'address': '北京市海淀区中关村大街123号门诊部',
      'isDefault': false,
    },
  ];

  // ========== 用户认证相关接口 ========== //

  /// 用户登录
  /// [username] 用户名
  /// [password] 密码
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> loginUser({
    required String username,
    required String password,
    bool isShowLoad = true,
  }) async {
    // 模拟加载状态

    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 1000));

    // 查找用户
    final user = _mockUsers.firstWhere(
      (u) => u['username'] == username && u['password'] == password,
      orElse: () => {},
    );

    // 加载完成

    if (user.isEmpty) {
      throw Exception('用户名或密码错误');
    }

    // 移除密码字段
    final result = Map<String, dynamic>.from(user);
    result.remove('password');

    return {
      'code': 200,
      'message': '登录成功',
      'data': {
        'token':
            'mock_token_${user['id']}_${DateTime.now().millisecondsSinceEpoch}',
        'userInfo': result,
      },
    };
  }

  /// 用户注册
  /// [username] 用户名
  /// [password] 密码
  /// [phone] 手机号
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> registerUser({
    required String username,
    required String password,
    required String phone,
    bool isShowLoad = true,
  }) async {
    // 模拟加载状态

    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 1000));

    // 检查用户名是否已存在
    final existingUser = _mockUsers.firstWhere(
      (u) => u['username'] == username,
      orElse: () => {},
    );

    // 加载完成

    if (existingUser.isNotEmpty) {
      throw Exception('用户名已存在');
    }

    // 创建新用户
    final newUser = {
      'id': '${1000 + _mockUsers.length + 1}',
      'username': username,
      'password': password,
      'phone': phone,
      'name': '新用户',
      'avatar': 'https://picsum.photos/200/200?random=${_random.nextInt(100)}',
      'department': '待完善',
      'title': '待完善',
      'hospital': '待完善',
      'certification': '待完善',
      'experience': '0年',
      'speciality': '待完善',
    };

    _mockUsers.add(newUser);

    // 移除密码字段
    final result = Map<String, dynamic>.from(newUser);
    result.remove('password');

    return {
      'code': 200,
      'message': '注册成功',
      'data': {
        'token':
            'mock_token_${newUser['id']}_${DateTime.now().millisecondsSinceEpoch}',
        'userInfo': result,
      },
    };
  }

  /// 获取用户信息
  /// [userId] 用户ID
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getUserInfo({
    required String userId,
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    final user = _mockUsers.firstWhere(
      (u) => u['id'] == userId,
      orElse: () => {},
    );

    if (user.isEmpty) {
      throw Exception('用户不存在');
    }

    // 移除密码字段
    final result = Map<String, dynamic>.from(user);
    result.remove('password');

    return {
      'code': 200,
      'message': '获取成功',
      'data': result,
    };
  }

  /// 更新用户信息
  /// [userInfo] 用户信息
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> updateUserInfo({
    required Map<String, dynamic> userInfo,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 800));

    final userId = userInfo['id'];
    final userIndex = _mockUsers.indexWhere((u) => u['id'] == userId);

    if (userIndex == -1) {
      throw Exception('用户不存在');
    }

    // 更新用户信息
    _mockUsers[userIndex] = {..._mockUsers[userIndex], ...userInfo};

    return {
      'code': 200,
      'message': '更新成功',
      'data': null,
    };
  }

  // ========== 工作台相关接口 ========== //

  /// 获取工作台数据
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getWorkbenchData({
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 600));

    return {
      'code': 200,
      'message': '获取成功',
      'data': {
        'todayPatients': 12,
        'monthlyIncome': 25680.50,
        'pendingTasks': 8,
        'totalRating': 4.8,
        'recentPatients': _mockPatients.take(3).toList(),
        'todaySchedule': [
          {
            'time': '09:00',
            'patient': '王小明',
            'type': '复诊',
            'status': '已完成',
          },
          {
            'time': '10:30',
            'patient': '李小红',
            'type': '初诊',
            'status': '进行中',
          },
          {
            'time': '14:00',
            'patient': '张大爷',
            'type': '复诊',
            'status': '待开始',
          },
        ],
        'notifications': [
          {
            'id': 'N001',
            'title': '新患者预约',
            'content': '患者李小红预约了明天上午的门诊',
            'time': '2024-01-16 15:30',
            'isRead': false,
          },
          {
            'id': 'N002',
            'title': '处方审核通过',
            'content': '王小明的处方已通过药师审核',
            'time': '2024-01-16 14:20',
            'isRead': true,
          },
        ],
      },
    };
  }

  // ========== 患者相关接口 ========== //

  /// 获取患者列表
  /// [page] 页码
  /// [keyword] 搜索关键词
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getPatientList({
    int page = 1,
    String? keyword,
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    List<Map<String, dynamic>> filteredPatients = _mockPatients;

    // 搜索过滤
    if (keyword != null && keyword.isNotEmpty) {
      filteredPatients = _mockPatients.where((patient) {
        return patient['name'].toString().contains(keyword) ||
            patient['phone'].toString().contains(keyword);
      }).toList();
    }

    // 分页
    const pageSize = 20;
    final startIndex = (page - 1) * pageSize;
    final endIndex = startIndex + pageSize;
    final paginatedPatients = filteredPatients.sublist(
      startIndex,
      endIndex > filteredPatients.length ? filteredPatients.length : endIndex,
    );

    return {
      'code': 200,
      'message': '获取成功',
      'data': {
        'list': paginatedPatients,
        'total': filteredPatients.length,
        'page': page,
        'pageSize': pageSize,
        'hasMore': endIndex < filteredPatients.length,
      },
    };
  }

  /// 添加患者
  /// [patientInfo] 患者信息
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> addPatient({
    required Map<String, dynamic> patientInfo,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 800));

    final newPatient = {
      'id': '${2000 + _mockPatients.length + 1}',
      ...patientInfo,
      'lastVisit': DateTime.now().toString().substring(0, 10),
      'status': '初诊',
    };

    _mockPatients.add(newPatient);

    return {
      'code': 200,
      'message': '添加成功',
      'data': newPatient,
    };
  }

  // ========== 处方相关接口 ========== //

  /// 获取处方列表
  /// [patientId] 患者ID
  /// [page] 页码
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getPrescriptionList({
    String? patientId,
    int page = 1,
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    List<Map<String, dynamic>> filteredPrescriptions = _mockPrescriptions;

    // 按患者ID过滤
    if (patientId != null && patientId.isNotEmpty) {
      filteredPrescriptions = _mockPrescriptions.where((prescription) {
        return prescription['patientId'] == patientId;
      }).toList();
    }

    // 分页
    const pageSize = 20;
    final startIndex = (page - 1) * pageSize;
    final endIndex = startIndex + pageSize;
    final paginatedPrescriptions = filteredPrescriptions.sublist(
      startIndex,
      endIndex > filteredPrescriptions.length
          ? filteredPrescriptions.length
          : endIndex,
    );

    return {
      'code': 200,
      'message': '获取成功',
      'data': {
        'list': paginatedPrescriptions,
        'total': filteredPrescriptions.length,
        'page': page,
        'pageSize': pageSize,
        'hasMore': endIndex < filteredPrescriptions.length,
      },
    };
  }

  /// 保存处方
  /// [prescriptionInfo] 处方信息
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> savePrescription({
    required Map<String, dynamic> prescriptionInfo,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 800));

    final newPrescription = {
      'id': 'P${(_mockPrescriptions.length + 1).toString().padLeft(3, '0')}',
      ...prescriptionInfo,
      'date': DateTime.now().toString().substring(0, 10),
      'status': '已开具',
    };

    _mockPrescriptions.add(newPrescription);

    return {
      'code': 200,
      'message': '保存成功',
      'data': newPrescription,
    };
  }

  // ========== 采购相关接口 ========== //

  /// 获取采购商品列表
  /// [page] 页码
  /// [category] 商品分类
  /// [keyword] 搜索关键词
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getPurchaseItemList({
    int page = 1,
    String? category,
    String? keyword,
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 600));

    List<Map<String, dynamic>> filteredItems = _mockPurchaseItems;

    // 分类过滤
    if (category != null && category.isNotEmpty) {
      filteredItems = filteredItems.where((item) {
        return item['category'] == category;
      }).toList();
    }

    // 搜索过滤
    if (keyword != null && keyword.isNotEmpty) {
      filteredItems = filteredItems.where((item) {
        return item['name'].toString().contains(keyword) ||
            item['brand'].toString().contains(keyword);
      }).toList();
    }

    // 分页
    const pageSize = 20;
    final startIndex = (page - 1) * pageSize;
    final endIndex = startIndex + pageSize;
    final paginatedItems = filteredItems.sublist(
      startIndex,
      endIndex > filteredItems.length ? filteredItems.length : endIndex,
    );

    return {
      'code': 200,
      'message': '获取成功',
      'data': {
        'list': paginatedItems,
        'total': filteredItems.length,
        'page': page,
        'pageSize': pageSize,
        'hasMore': endIndex < filteredItems.length,
        'categories': ['防护用品', '消毒用品', '医疗器械', '检测设备'],
      },
    };
  }

  /// 获取商品详情
  /// [itemId] 商品ID
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getPurchaseItemDetail({
    required String itemId,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    final item = _mockPurchaseItems.firstWhere(
      (i) => i['id'] == itemId,
      orElse: () => {},
    );

    if (item.isEmpty) {
      throw Exception('商品不存在');
    }

    return {
      'code': 200,
      'message': '获取成功',
      'data': item,
    };
  }

  /// 创建采购订单
  /// [orderInfo] 订单信息
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> createPurchaseOrder({
    required Map<String, dynamic> orderInfo,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 1000));

    final newOrder = {
      'id': 'O${(_mockPurchaseOrders.length + 1).toString().padLeft(3, '0')}',
      'orderNo':
          'PO${DateTime.now().toString().replaceAll(RegExp(r'[^0-9]'), '').substring(0, 14)}',
      'date': DateTime.now().toString().substring(0, 10),
      'status': 0,
      'statusText': '待确认',
      ...orderInfo,
    };

    _mockPurchaseOrders.add(newOrder);

    return {
      'code': 200,
      'message': '订单创建成功',
      'data': newOrder,
    };
  }

  /// 获取采购订单列表
  /// [page] 页码
  /// [status] 订单状态
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getPurchaseOrderList({
    int page = 1,
    int? status,
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    List<Map<String, dynamic>> filteredOrders = _mockPurchaseOrders;

    // 状态过滤
    if (status != null) {
      filteredOrders = filteredOrders.where((order) {
        return order['status'] == status;
      }).toList();
    }

    // 分页
    const pageSize = 20;
    final startIndex = (page - 1) * pageSize;
    final endIndex = startIndex + pageSize;
    final paginatedOrders = filteredOrders.sublist(
      startIndex,
      endIndex > filteredOrders.length ? filteredOrders.length : endIndex,
    );

    return {
      'code': 200,
      'message': '获取成功',
      'data': {
        'list': paginatedOrders,
        'total': filteredOrders.length,
        'page': page,
        'pageSize': pageSize,
        'hasMore': endIndex < filteredOrders.length,
      },
    };
  }

  // ========== 地址相关接口 ========== //

  /// 获取地址列表
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> getAddressList({
    bool isShowLoad = false,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 400));

    return {
      'code': 200,
      'message': '获取成功',
      'data': _mockAddresses,
    };
  }

  /// 保存地址
  /// [addressInfo] 地址信息
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> saveAddress({
    required Map<String, dynamic> addressInfo,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 600));

    final addressId = addressInfo['id'];

    if (addressId != null) {
      // 更新地址
      final addressIndex =
          _mockAddresses.indexWhere((a) => a['id'] == addressId);
      if (addressIndex != -1) {
        _mockAddresses[addressIndex] = {
          ..._mockAddresses[addressIndex],
          ...addressInfo
        };
      }
    } else {
      // 新增地址
      final newAddress = {
        'id': 'A${(_mockAddresses.length + 1).toString().padLeft(3, '0')}',
        ...addressInfo,
      };
      _mockAddresses.add(newAddress);
    }

    return {
      'code': 200,
      'message': '保存成功',
      'data': null,
    };
  }

  /// 删除地址
  /// [addressId] 地址ID
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> deleteAddress({
    required String addressId,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 500));

    _mockAddresses.removeWhere((a) => a['id'] == addressId);

    return {
      'code': 200,
      'message': '删除成功',
      'data': null,
    };
  }

  // ========== 通用接口 ========== //

  /// 上传文件
  /// [filePath] 文件路径
  /// [isShowLoad] 是否显示加载动画
  static Future<Map<String, dynamic>> uploadFile({
    required String filePath,
    bool isShowLoad = true,
  }) async {
    // 模拟网络延迟
    await Future.delayed(const Duration(milliseconds: 2000));

    // 模拟上传成功，返回文件URL
    final fileName = filePath.split('/').last;
    final fileUrl =
        'https://picsum.photos/400/400?random=${_random.nextInt(1000)}';

    return {
      'code': 200,
      'message': '上传成功',
      'data': {
        'fileName': fileName,
        'fileUrl': fileUrl,
        'fileSize': _random.nextInt(1000000) + 100000, // 随机文件大小
      },
    };
  }
}
